home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 335_02 / as6805.y < prev    next >
Encoding:
Lex Description  |  1990-12-02  |  36.3 KB  |  1,656 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     as6805.y;
  13. WARNINGS:     "This software is in the public domain.  
  14.         Any prior copyright claims are relinquished.  
  15.  
  16.         This software is distributed with no warranty whatever.  
  17.         The author takes no responsibility for the consequences 
  18.         of its use.
  19.  
  20.         Yacc (or Bison) required to compile."  ;
  21. SEE-ALSO:     as6805.doc,frasmain.c;    
  22. AUTHORS:     Mark Zenier;
  23. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  24.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  25. */
  26. /* 6805 instruction generation file */
  27. /* November 17, 1990 */
  28.  
  29. /*
  30.     description    frame work parser description for framework cross
  31.             assemblers
  32.     history        February 2, 1988
  33.             September 11, 1990 - merge table definition
  34.             September 12, 1990 - short file names
  35.             September 14, 1990 - short variable names
  36.             September 17, 1990 - use yylex as external
  37. */
  38. #include <stdio.h>
  39. #include "frasmdat.h"
  40. #include "fragcon.h"
  41.  
  42. #define yylex lexintercept
  43.  
  44. /*
  45.     file        fraselcrit.h
  46.     author        Mark Zenier
  47.     description    Selection criteria and token values for 6805
  48.             framework assembler
  49.     usage        framework cross assembler
  50.     history        September 19, 1987
  51.             October 2, 1987
  52.             June 7, 1989  fix relative addressing (BRset/clr)
  53. */
  54.     /* selectors for the ST_EXP address */
  55.     /* 0000 0000 0000 00xx */
  56. #define ADDR        0x3
  57. #define DIRECT        0x1
  58. #define EXTENDED    0x2
  59.  
  60.     /* selectors for the ST_IND offset */
  61.     /* 0000 0000 000x xx00 */
  62. #define INDEXLEN    0x1C
  63. #define INDEX0        0x4
  64. #define INDEX1        0x8
  65. #define INDEX2        0x10
  66.  
  67.     /* selectors for instruction set extensions */
  68.     /* 0000 0000 xxx0 0000 */
  69. #define INSTSTWA    0x20
  70. #define INSTMUL    0x40
  71. #define INSTDAA    0x80
  72.  
  73.     /* cpu instruction extensions */
  74. #define CPU6805    0
  75. #define CPU146805    INSTSTWA
  76. #define CPU68HC05    (INSTSTWA | INSTMUL)
  77. #define CPU6305    (INSTSTWA | INSTDAA)
  78. #define ST_BRSET 0x1
  79. #define ST_BSET 0x2
  80. #define ST_EXP 0x4
  81. #define ST_IMM 0x8
  82. #define ST_IND 0x10
  83. #define ST_INH 0x20
  84.     
  85.     int    cpuselect = CPU6805;
  86.     static char    genbdef[] = "[1=];";
  87.     static char    genwdef[] = "[1=]x";
  88.     char ignosyn[] = "[Xinvalid syntax for instruction";
  89.     char ignosel[] = "[Xinvalid operands/illegal instruction for cpu";
  90.  
  91.     long    labelloc;
  92.     static int satsub;
  93.     int    ifstkpt = 0;
  94.     int    fraifskip = FALSE;
  95.  
  96.     struct symel * endsymbol = SYMNULL;
  97.  
  98. %}
  99. %union {
  100.     int    intv;
  101.     long     longv;
  102.     char    *strng;
  103.     struct symel *symb;
  104.     struct {int indexv, ex; } inetre;
  105. }
  106.  
  107. %token <intv> INDEX
  108. %type <inetre> indexed
  109. %token <intv> KOC_BDEF
  110. %token <intv> KOC_ELSE
  111. %token <intv> KOC_END
  112. %token <intv> KOC_ENDI
  113. %token <intv> KOC_EQU
  114. %token <intv> KOC_IF
  115. %token <intv> KOC_INCLUDE
  116. %token <intv> KOC_ORG
  117. %token <intv> KOC_RESM
  118. %token <intv> KOC_SDEF
  119. %token <intv> KOC_SET
  120. %token <intv> KOC_WDEF
  121. %token <intv> KOC_CHSET
  122. %token <intv> KOC_CHDEF
  123. %token <intv> KOC_CHUSE
  124. %token <intv> KOC_CPU
  125. %token <intv> KOC_opcode
  126.  
  127. %token <longv> CONSTANT
  128. %token EOL
  129. %token KEOP_AND
  130. %token KEOP_DEFINED
  131. %token KEOP_EQ
  132. %token KEOP_GE
  133. %token KEOP_GT
  134. %token KEOP_HIGH
  135. %token KEOP_LE
  136. %token KEOP_LOW
  137. %token KEOP_LT
  138. %token KEOP_MOD
  139. %token KEOP_MUN
  140. %token KEOP_NE
  141. %token KEOP_NOT
  142. %token KEOP_OR
  143. %token KEOP_SHL
  144. %token KEOP_SHR
  145. %token KEOP_XOR
  146. %token KEOP_locctr
  147. %token <symb> LABEL
  148. %token <strng> STRING
  149. %token <symb> SYMBOL
  150.  
  151. %token KTK_invalid
  152.  
  153. %right    KEOP_HIGH KEOP_LOW
  154. %left    KEOP_OR KEOP_XOR
  155. %left    KEOP_AND
  156. %right    KEOP_NOT
  157. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  158. %left    '+' '-'
  159. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  160. %right    KEOP_MUN
  161.  
  162.  
  163. %type <intv> expr exprlist stringlist
  164.  
  165. %start file
  166.  
  167. %%
  168.  
  169. file    :    file allline
  170.     |    allline
  171.     ;
  172.  
  173. allline    :     line EOL
  174.             {
  175.                 clrexpr();
  176.             }
  177.     |    EOL
  178.     |    error EOL
  179.             {
  180.                 clrexpr();
  181.                 yyerrok;
  182.             }
  183.     ;
  184.  
  185. line    :    LABEL KOC_END 
  186.             {
  187.                 endsymbol = $1;
  188.                 nextreadact = Nra_end;
  189.             }
  190.     |          KOC_END 
  191.             {
  192.                 nextreadact = Nra_end;
  193.             }
  194.     |    KOC_INCLUDE STRING
  195.             {
  196.         if(nextfstk >= FILESTKDPTH)
  197.         {
  198.             fraerror("include file nesting limit exceeded");
  199.         }
  200.         else
  201.         {
  202.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  203.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  204.                 ==(FILE *)NULL )
  205.             {
  206.                 fraerror("cannot open include file");
  207.             }
  208.             else
  209.             {
  210.                 nextreadact = Nra_new;
  211.             }
  212.         }
  213.             }
  214.     |    LABEL KOC_EQU expr 
  215.             {
  216.                 if($1 -> seg == SSG_UNDEF)
  217.                 {
  218.                     pevalexpr(0, $3);
  219.                     if(evalr[0].seg == SSG_ABS)
  220.                     {
  221.                         $1 -> seg = SSG_EQU;
  222.                         $1 -> value = evalr[0].value;
  223.                         prtequvalue("C: 0x%lx\n",
  224.                             evalr[0].value);
  225.                     }
  226.                     else
  227.                     {
  228.                         fraerror(
  229.                     "noncomputable expression for EQU");
  230.                     }
  231.                 }
  232.                 else
  233.                 {
  234.                     fraerror(
  235.                 "cannot change symbol value with EQU");
  236.                 }
  237.             }
  238.     |    LABEL KOC_SET expr 
  239.             {
  240.                 if($1 -> seg == SSG_UNDEF
  241.                    || $1 -> seg == SSG_SET)
  242.                 {
  243.                     pevalexpr(0, $3);
  244.                     if(evalr[0].seg == SSG_ABS)
  245.                     {
  246.                         $1 -> seg = SSG_SET;
  247.                         $1 -> value = evalr[0].value;
  248.                         prtequvalue("C: 0x%lx\n",
  249.                             evalr[0].value);
  250.                     }
  251.                     else
  252.                     {
  253.                         fraerror(
  254.                     "noncomputable expression for SET");
  255.                     }
  256.                 }
  257.                 else
  258.                 {
  259.                     fraerror(
  260.                 "cannot change symbol value with SET");
  261.                 }
  262.             }
  263.     |    KOC_IF expr 
  264.             {
  265.         if((++ifstkpt) < IFSTKDEPTH)
  266.         {
  267.             pevalexpr(0, $2);
  268.             if(evalr[0].seg == SSG_ABS)
  269.             {
  270.                 if(evalr[0].value != 0)
  271.                 {
  272.                     elseifstk[ifstkpt] = If_Skip;
  273.                     endifstk[ifstkpt] = If_Active;
  274.                 }
  275.                 else
  276.                 {
  277.                     fraifskip = TRUE;
  278.                     elseifstk[ifstkpt] = If_Active;
  279.                     endifstk[ifstkpt] = If_Active;
  280.                 }
  281.             }
  282.             else
  283.             {
  284.                 fraifskip = TRUE;
  285.                 elseifstk[ifstkpt] = If_Active;
  286.                 endifstk[ifstkpt] = If_Active;
  287.             }
  288.         }
  289.         else
  290.         {
  291.             fraerror("IF stack overflow");
  292.         }
  293.             }
  294.                         
  295.     |    KOC_IF 
  296.             {
  297.         if(fraifskip) 
  298.         {
  299.             if((++ifstkpt) < IFSTKDEPTH)
  300.             {
  301.                     elseifstk[ifstkpt] = If_Skip;
  302.                     endifstk[ifstkpt] = If_Skip;
  303.             }
  304.             else
  305.             {
  306.                 fraerror("IF stack overflow");
  307.             }
  308.         }
  309.         else
  310.         {
  311.             yyerror("syntax error");
  312.             YYERROR;
  313.         }
  314.                 }
  315.                         
  316.     |    KOC_ELSE 
  317.             {
  318.                 switch(elseifstk[ifstkpt])
  319.                 {
  320.                 case If_Active:
  321.                     fraifskip = FALSE;
  322.                     break;
  323.                 
  324.                 case If_Skip:
  325.                     fraifskip = TRUE;
  326.                     break;
  327.                 
  328.                 case If_Err:
  329.                     fraerror("ELSE with no matching if");
  330.                     break;
  331.                 }
  332.             }
  333.  
  334.     |    KOC_ENDI 
  335.             {
  336.                 switch(endifstk[ifstkpt])
  337.                 {
  338.                 case If_Active:
  339.                     fraifskip = FALSE;
  340.                     ifstkpt--;
  341.                     break;
  342.                 
  343.                 case If_Skip:
  344.                     fraifskip = TRUE;
  345.                     ifstkpt--;
  346.                     break;
  347.                 
  348.                 case If_Err:
  349.                     fraerror("ENDI with no matching if");
  350.                     break;
  351.                 }
  352.             }
  353.     |    LABEL KOC_ORG expr 
  354.             {
  355.                 pevalexpr(0, $3);
  356.                 if(evalr[0].seg == SSG_ABS)
  357.                 {
  358.                     locctr = labelloc = evalr[0].value;
  359.                     if($1 -> seg == SSG_UNDEF)
  360.                     {
  361.                         $1 -> seg = SSG_ABS;
  362.                         $1 -> value = labelloc;
  363.                     }
  364.                     else
  365.                         fraerror(
  366.                         "multiple definition of label");
  367.                     prtequvalue("C: 0x%lx\n",
  368.                         evalr[0].value);
  369.                 }
  370.                 else
  371.                 {
  372.                     fraerror(
  373.                      "noncomputable expression for ORG");
  374.                 }
  375.             }
  376.     |          KOC_ORG expr 
  377.             {
  378.                 pevalexpr(0, $2);
  379.                 if(evalr[0].seg == SSG_ABS)
  380.                 {
  381.                     locctr = labelloc = evalr[0].value;
  382.                     prtequvalue("C: 0x%lx\n",
  383.                         evalr[0].value);
  384.                 }
  385.                 else
  386.                 {
  387.                     fraerror(
  388.                      "noncomputable expression for ORG");
  389.                 }
  390.             }
  391.     |    LABEL KOC_CHSET
  392.             {
  393.                 if($1 -> seg == SSG_UNDEF)
  394.                 {
  395.                     $1 -> seg = SSG_EQU;
  396.                     if( ($1->value = chtcreate()) <= 0)
  397.                     {
  398.         fraerror( "cannot create character translation table");
  399.                     }
  400.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  401.                 }
  402.                 else
  403.                 {
  404.             fraerror( "multiple definition of label");
  405.                 }
  406.             }
  407.     |        KOC_CHUSE
  408.             {
  409.                 chtcpoint = (int *) NULL;
  410.                 prtequvalue("C: 0x%lx\n", 0L);
  411.             }
  412.     |        KOC_CHUSE expr
  413.             {
  414.                 pevalexpr(0, $2);
  415.                 if( evalr[0].seg == SSG_ABS)
  416.                 {
  417.                     if( evalr[0].value == 0)
  418.                     {
  419.                         chtcpoint = (int *)NULL;
  420.                         prtequvalue("C: 0x%lx\n", 0L);
  421.                     }
  422.                     else if(evalr[0].value < chtnxalph)
  423.                     {
  424.                 chtcpoint = chtatab[evalr[0].value];
  425.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  426.                     }
  427.                     else
  428.                     {
  429.             fraerror("nonexistent character translation table");
  430.                     }
  431.                 }
  432.                 else
  433.                 {
  434.                     fraerror("noncomputable expression");
  435.                 }
  436.             }
  437.     |        KOC_CHDEF STRING ',' exprlist
  438.             {
  439.         int findrv, numret, *charaddr;
  440.         char *sourcestr = $2, *before;
  441.  
  442.         if(chtnpoint != (int *)NULL)
  443.         {
  444.             for(satsub = 0; satsub < $4; satsub++)
  445.             {
  446.                 before = sourcestr;
  447.  
  448.                 pevalexpr(0, exprlist[satsub]);
  449.                 findrv = chtcfind(chtnpoint, &sourcestr,
  450.                         &charaddr, &numret);
  451.                 if(findrv == CF_END)
  452.                 {
  453.             fraerror("more expressions than characters");
  454.                     break;
  455.                 }
  456.  
  457.                 if(evalr[0].seg == SSG_ABS)
  458.                 {
  459.                     switch(findrv)
  460.                     {
  461.                     case CF_UNDEF:
  462.                         {
  463.                 if(evalr[0].value < 0 ||
  464.                     evalr[0].value > 255)
  465.                 {
  466.             frawarn("character translation value truncated");
  467.                 }
  468.                 *charaddr = evalr[0].value & 0xff;
  469.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  470.                         }
  471.                         break;
  472.  
  473.                     case CF_INVALID:
  474.                     case CF_NUMBER:
  475.                 fracherror("invalid character to define", 
  476.                     before, sourcestr);
  477.                         break;
  478.  
  479.                     case CF_CHAR:
  480.                 fracherror("character already defined", 
  481.                     before, sourcestr);
  482.                         break;
  483.                     }
  484.                 }
  485.                 else
  486.                 {
  487.                     fraerror("noncomputable expression");
  488.                 }
  489.             }
  490.  
  491.             if( *sourcestr != '\0')
  492.             {
  493.                 fraerror("more characters than expressions");
  494.             }
  495.         }
  496.         else
  497.         {
  498.             fraerror("no CHARSET statement active");
  499.         }
  500.             
  501.             }
  502.     |    LABEL 
  503.             {
  504.             if($1 -> seg == SSG_UNDEF)
  505.             {
  506.                 $1 -> seg = SSG_ABS;
  507.                 $1 -> value = labelloc;
  508.                 prtequvalue("C: 0x%lx\n", labelloc);
  509.  
  510.             }
  511.             else
  512.                 fraerror(
  513.                 "multiple definition of label");
  514.             }
  515.     |    labeledline
  516.     ;
  517.  
  518. labeledline :    LABEL genline
  519.             {
  520.             if($1 -> seg == SSG_UNDEF)
  521.             {
  522.                 $1 -> seg = SSG_ABS;
  523.                 $1 -> value = labelloc;
  524.             }
  525.             else
  526.                 fraerror(
  527.                 "multiple definition of label");
  528.             labelloc = locctr;
  529.             }
  530.                 
  531.     |    genline
  532.             {
  533.                 labelloc = locctr;
  534.             }
  535.     ;
  536.  
  537. genline    :    KOC_BDEF    exprlist 
  538.             {
  539.                 genlocrec(currseg, labelloc);
  540.                 for( satsub = 0; satsub < $2; satsub++)
  541.                 {
  542.                     pevalexpr(1, exprlist[satsub]);
  543.                     locctr += geninstr(genbdef);
  544.                 }
  545.             }
  546.     |    KOC_SDEF stringlist 
  547.             {
  548.                 genlocrec(currseg, labelloc);
  549.                 for(satsub = 0; satsub < $2; satsub++)
  550.                 {
  551.                     locctr += genstring(stringlist[satsub]);
  552.                 }
  553.             }
  554.     |    KOC_WDEF exprlist 
  555.             {
  556.                 genlocrec(currseg, labelloc);
  557.                 for( satsub = 0; satsub < $2; satsub++)
  558.                 {
  559.                     pevalexpr(1, exprlist[satsub]);
  560.                     locctr += geninstr(genwdef);
  561.                 }
  562.             }    
  563.     |    KOC_RESM expr 
  564.             {
  565.                 pevalexpr(0, $2);
  566.                 if(evalr[0].seg == SSG_ABS)
  567.                 {
  568.                     locctr = labelloc + evalr[0].value;
  569.                     prtequvalue("C: 0x%lx\n", labelloc);
  570.                 }
  571.                 else
  572.                 {
  573.                     fraerror(
  574.                  "noncomputable result for RMB expression");
  575.                 }
  576.             }
  577.     ;
  578.  
  579. exprlist :    exprlist ',' expr
  580.             {
  581.                 exprlist[nextexprs ++ ] = $3;
  582.                 $$ = nextexprs;
  583.             }
  584.     |    expr
  585.             {
  586.                 nextexprs = 0;
  587.                 exprlist[nextexprs ++ ] = $1;
  588.                 $$ = nextexprs;
  589.             }
  590.     ;
  591.  
  592. stringlist :    stringlist ',' STRING
  593.             {
  594.                 stringlist[nextstrs ++ ] = $3;
  595.                 $$ = nextstrs;
  596.             }
  597.     |    STRING
  598.             {
  599.                 nextstrs = 0;
  600.                 stringlist[nextstrs ++ ] = $1;
  601.                 $$ = nextstrs;
  602.             }
  603.     ;
  604.  
  605.  
  606. line    :    KOC_CPU STRING
  607.             {
  608.         if( ! cpumatch($2))
  609.         {
  610.             fraerror("unknown cpu type, 6805 assumed");
  611.             cpuselect = CPU6805;
  612.         }
  613.             }
  614.     ;
  615. genline : KOC_opcode  expr ',' expr ',' expr
  616.             {
  617.         pevalexpr(1,$2);
  618.         if(evalr[1].seg != SSG_ABS || 
  619.             evalr[1].value < 0 ||
  620.             evalr[1].value > 7)
  621.         {
  622.             evalr[1].value = 0;
  623.             fraerror("impossible bit number");
  624.         }
  625.         else
  626.         {
  627.             evalr[1].value *= 2;
  628.         }
  629.         pevalexpr(2,$4);
  630.         pevalexpr(3,$6);
  631.         genlocrec(currseg, labelloc);
  632.         locctr += geninstr( findgen($1, ST_BRSET, 0));
  633.             }
  634.     ;
  635. genline : KOC_opcode  expr ',' expr
  636.             {
  637.         pevalexpr(1,$2);
  638.         if(evalr[1].seg != SSG_ABS || 
  639.             evalr[1].value < 0 ||
  640.             evalr[1].value > 7)
  641.         {
  642.             evalr[1].value = 0;
  643.             fraerror("impossible bit number");
  644.         }
  645.         else
  646.         {
  647.             evalr[1].value *= 2;
  648.         }
  649.         pevalexpr(2,$4);
  650.         genlocrec(currseg, labelloc);
  651.         locctr += geninstr( findgen( $1, ST_BSET, 0));
  652.             }
  653.     ;
  654. genline : KOC_opcode  expr
  655.             {
  656.         pevalexpr(1, $2);
  657.         genlocrec(currseg, labelloc);
  658.         locctr += geninstr( findgen( $1, ST_EXP, 
  659.                   ( (evalr[1].seg == SSG_ABS 
  660.                 && evalr[1].value >= 0
  661.                 && evalr[1].value <= 255 )
  662.                 ? DIRECT : EXTENDED ) )
  663.                 );
  664.             }
  665.     ;
  666. genline : KOC_opcode  '#' expr
  667.             {
  668.         pevalexpr(1, $3);
  669.         genlocrec(currseg, labelloc);
  670.         locctr += geninstr( findgen($1, ST_IMM, 0));
  671.             }
  672.     ;
  673. genline : KOC_opcode  indexed
  674.             {
  675.         int selcrit = INDEX2;
  676.  
  677.         pevalexpr(1, $2.ex);
  678.  
  679.         if(evalr[1].seg == SSG_ABS)
  680.         {
  681.             if(evalr[1].value == 0)
  682.             {
  683.                 selcrit = INDEX0;
  684.             }
  685.             else if(evalr[1].value > 0 && evalr[1].value <= 255)
  686.             {
  687.                 selcrit = INDEX1;
  688.             }
  689.         }
  690.  
  691.         genlocrec(currseg, labelloc);
  692.         locctr += geninstr( findgen($1, ST_IND, selcrit));
  693.             }
  694.     ;
  695. genline : KOC_opcode 
  696.             {
  697.         genlocrec(currseg, labelloc);
  698.         locctr += geninstr(findgen($1, ST_INH, cpuselect));
  699.             }
  700.     ;
  701.  
  702. indexed    :    ',' INDEX    
  703.             {
  704.                 $$.indexv = $2;
  705.                 $$.ex = exprnode(PCCASE_CONS,0,
  706.                     IGP_CONSTANT,0,
  707.                     (long)0, SYMNULL);
  708.             }
  709.     |    expr ',' INDEX
  710.             {
  711.                 $$.ex = $1;
  712.                 $$.indexv = $3;
  713.             }
  714.     ;
  715.  
  716. expr    :    '+' expr %prec KEOP_MUN
  717.             {
  718.                 $$ = $2;
  719.             }
  720.     |    '-' expr %prec KEOP_MUN
  721.             {
  722.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  723.                     SYMNULL);
  724.             }
  725.     |    KEOP_NOT expr
  726.             {
  727.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  728.                     SYMNULL);
  729.             }
  730.     |    KEOP_HIGH expr
  731.             {
  732.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  733.                     SYMNULL);
  734.             }
  735.     |    KEOP_LOW expr
  736.             {
  737.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  738.                     SYMNULL);
  739.             }
  740.     |    expr '*' expr
  741.             {
  742.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  743.                     SYMNULL);
  744.             }
  745.     |    expr '/' expr
  746.             {
  747.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  748.                     SYMNULL);
  749.             }
  750.     |    expr '+' expr
  751.             {
  752.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  753.                     SYMNULL);
  754.             }
  755.     |    expr '-' expr
  756.             {
  757.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  758.                     SYMNULL);
  759.             }
  760.     |    expr KEOP_MOD expr
  761.             {
  762.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  763.                     SYMNULL);
  764.             }
  765.     |    expr KEOP_SHL expr
  766.             {
  767.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  768.                     SYMNULL);
  769.             }
  770.     |    expr KEOP_SHR expr
  771.             {
  772.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  773.                     SYMNULL);
  774.             }
  775.     |    expr KEOP_GT expr
  776.             {
  777.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  778.                     SYMNULL);
  779.             }
  780.     |    expr KEOP_GE expr
  781.             {
  782.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  783.                     SYMNULL);
  784.             }
  785.     |    expr KEOP_LT expr
  786.             {
  787.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  788.                     SYMNULL);
  789.             }
  790.     |    expr KEOP_LE expr
  791.             {
  792.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  793.                     SYMNULL);
  794.             }
  795.     |    expr KEOP_NE expr
  796.             {
  797.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  798.                     SYMNULL);
  799.             }
  800.     |    expr KEOP_EQ expr
  801.             {
  802.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  803.                     SYMNULL);
  804.             }
  805.     |    expr KEOP_AND expr
  806.             {
  807.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  808.                     SYMNULL);
  809.             }
  810.     |    expr KEOP_OR expr
  811.             {
  812.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  813.                     SYMNULL);
  814.             }
  815.     |    expr KEOP_XOR expr
  816.             {
  817.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  818.                     SYMNULL);
  819.             }
  820.     |    KEOP_DEFINED SYMBOL
  821.             {
  822.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  823.             }
  824.     |    SYMBOL
  825.             {
  826.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  827.             }
  828.     |    '*'
  829.             {
  830.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  831.                     labelloc, SYMNULL);
  832.             }
  833.     |    CONSTANT
  834.             {
  835.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  836.                     SYMNULL);
  837.             }
  838.     |    STRING
  839.             {
  840.                 char *sourcestr = $1;
  841.                 long accval = 0;
  842.  
  843.                 if(strlen($1) > 0)
  844.                 {
  845.                     accval = chtran(&sourcestr);
  846.                     if(*sourcestr != '\0')
  847.                     {
  848.                         accval = (accval << 8) +
  849.                             chtran(&sourcestr);
  850.                     }
  851.  
  852.                     if( *sourcestr != '\0')
  853.                     {
  854.     frawarn("string constant in expression more than 2 characters long");
  855.                     }
  856.                 }
  857.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  858.                     accval, SYMNULL);
  859.             }
  860.     |    '(' expr ')'
  861.             {
  862.                 $$ = $2;
  863.             }
  864.     ;
  865.  
  866.  
  867. %%
  868.  
  869. lexintercept()
  870. /*
  871.     description    intercept the call to yylex (the lexical analyzer)
  872.             and filter out all unnecessary tokens when skipping
  873.             the input between a failed IF and its matching ENDI or
  874.             ELSE
  875.     globals     fraifskip    the enable flag
  876. */
  877. {
  878. #undef yylex
  879.  
  880.     int rv;
  881.  
  882.     if(fraifskip)
  883.     {
  884.         for(;;)
  885.         {
  886.  
  887.             switch(rv = yylex())
  888.  
  889.             {
  890.             case 0:
  891.             case KOC_END:
  892.             case KOC_IF:
  893.             case KOC_ELSE:
  894.             case KOC_ENDI:
  895.             case EOL:
  896.                 return rv;
  897.             default:
  898.                 break;
  899.             }
  900.         }
  901.     }
  902.     else
  903.         return yylex();
  904. #define yylex lexintercept
  905. }
  906.  
  907.  
  908. setreserved()
  909. {
  910. /* machine dependent */
  911.     reservedsym("x", INDEX, 0);
  912.     reservedsym("X", INDEX, 0);
  913.  
  914.  
  915.     reservedsym("and", KEOP_AND, 0);
  916.     reservedsym("defined", KEOP_DEFINED,0);
  917.     reservedsym("eq", KEOP_EQ, 0);
  918.     reservedsym("ge", KEOP_GE, 0);
  919.     reservedsym("gt", KEOP_GT, 0);
  920.     reservedsym("high", KEOP_HIGH, 0);
  921.     reservedsym("le", KEOP_LE, 0);
  922.     reservedsym("low", KEOP_LOW, 0);
  923.     reservedsym("lt", KEOP_LT, 0);
  924.     reservedsym("mod", KEOP_MOD, 0);
  925.     reservedsym("ne", KEOP_NE, 0);
  926.     reservedsym("not", KEOP_NOT, 0);
  927.     reservedsym("or", KEOP_OR, 0);
  928.     reservedsym("shl", KEOP_SHL, 0);
  929.     reservedsym("shr", KEOP_SHR, 0);
  930.     reservedsym("xor", KEOP_XOR, 0);
  931.     reservedsym("AND", KEOP_AND, 0);
  932.     reservedsym("DEFINED", KEOP_DEFINED,0);
  933.     reservedsym("EQ", KEOP_EQ, 0);
  934.     reservedsym("GE", KEOP_GE, 0);
  935.     reservedsym("GT", KEOP_GT, 0);
  936.     reservedsym("HIGH", KEOP_HIGH, 0);
  937.     reservedsym("LE", KEOP_LE, 0);
  938.     reservedsym("LOW", KEOP_LOW, 0);
  939.     reservedsym("LT", KEOP_LT, 0);
  940.     reservedsym("MOD", KEOP_MOD, 0);
  941.     reservedsym("NE", KEOP_NE, 0);
  942.     reservedsym("NOT", KEOP_NOT, 0);
  943.     reservedsym("OR", KEOP_OR, 0);
  944.     reservedsym("SHL", KEOP_SHL, 0);
  945.     reservedsym("SHR", KEOP_SHR, 0);
  946.     reservedsym("XOR", KEOP_XOR, 0);
  947.  
  948. }
  949.  
  950. cpumatch(str)
  951.     char * str;
  952. {
  953.     int msub;
  954.  
  955.     static struct
  956.     {
  957.         char * mtch;
  958.         int   cpuv;
  959.     } matchtab[] =
  960.     {
  961.         {"4", CPU146805 },
  962.         {"hc", CPU68HC05 },
  963.         {"HC", CPU68HC05 },
  964.         {"l05", CPU6805 },
  965.         {"L05", CPU6805 },
  966.         {"3", CPU6305 },
  967.         {"05", CPU6805 },
  968.         {"", 0} 
  969.     };
  970.  
  971.     for(msub = 0; matchtab[msub].mtch[0] != '\0'; msub++)
  972.     {
  973.         if(strcontains(str, matchtab[msub].mtch))
  974.         {
  975.             cpuselect = matchtab[msub].cpuv;
  976.             return TRUE;
  977.         }
  978.     }
  979.  
  980.     return FALSE;
  981. }
  982.  
  983.  
  984. strcontains(s1, sm)
  985.     char * s1, *sm;
  986. {
  987.     int l1 = strlen(s1), lm = strlen(sm);
  988.  
  989.     for(; l1 >= lm; l1--, s1++)
  990.     {
  991.         if(strncmp(s1, sm, lm) == 0)
  992.         {
  993.             return TRUE;
  994.         }
  995.     }
  996.     return FALSE;
  997. }
  998.  
  999. /*
  1000.     description    Opcode and Instruction generation tables
  1001.     usage        Unix, framework crossassembler
  1002.     history        September 25, 1987
  1003. */
  1004.  
  1005. #define NUMOPCODE 115
  1006. #define NUMSYNBLK 132
  1007. #define NUMDIFFOP 192
  1008.  
  1009. int gnumopcode = NUMOPCODE;
  1010.  
  1011. int ophashlnk[NUMOPCODE];
  1012.  
  1013. struct opsym optab[NUMOPCODE+1]
  1014.     = {
  1015.     {"invalid", KOC_opcode, 2, 0 },
  1016.     {"ADC", KOC_opcode, 3, 2 },
  1017.     {"ADD", KOC_opcode, 3, 5 },
  1018.     {"AND", KOC_opcode, 3, 8 },
  1019.     {"ASL", KOC_opcode, 2, 11 },
  1020.     {"ASLA", KOC_opcode, 1, 13 },
  1021.     {"ASLX", KOC_opcode, 1, 14 },
  1022.     {"ASR", KOC_opcode, 2, 15 },
  1023.     {"ASRA", KOC_opcode, 1, 17 },
  1024.     {"ASRX", KOC_opcode, 1, 18 },
  1025.     {"BCC", KOC_opcode, 1, 19 },
  1026.     {"BCLR", KOC_opcode, 1, 20 },
  1027.     {"BCS", KOC_opcode, 1, 21 },
  1028.     {"BEQ", KOC_opcode, 1, 22 },
  1029.     {"BHCC", KOC_opcode, 1, 23 },
  1030.     {"BHCS", KOC_opcode, 1, 24 },
  1031.     {"BHI", KOC_opcode, 1, 25 },
  1032.     {"BHS", KOC_opcode, 1, 26 },
  1033.     {"BIH", KOC_opcode, 1, 27 },
  1034.     {"BIL", KOC_opcode, 1, 28 },
  1035.     {"BIT", KOC_opcode, 3, 29 },
  1036.     {"BLO", KOC_opcode, 1, 32 },
  1037.     {"BLS", KOC_opcode, 1, 33 },
  1038.     {"BMC", KOC_opcode, 1, 34 },
  1039.     {"BMI", KOC_opcode, 1, 35 },
  1040.     {"BMS", KOC_opcode, 1, 36 },
  1041.     {"BNE", KOC_opcode, 1, 37 },
  1042.     {"BPL", KOC_opcode, 1, 38 },
  1043.     {"BRA", KOC_opcode, 1, 39 },
  1044.     {"BRCLR", KOC_opcode, 1, 40 },
  1045.     {"BRN", KOC_opcode, 1, 41 },
  1046.     {"BRSET", KOC_opcode, 1, 42 },
  1047.     {"BSET", KOC_opcode, 1, 43 },
  1048.     {"BSR", KOC_opcode, 1, 44 },
  1049.     {"BYTE", KOC_BDEF, 0, 0 },
  1050.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1051.     {"CHARSET", KOC_CHSET, 0, 0 },
  1052.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1053.     {"CHD", KOC_CHDEF, 0, 0 },
  1054.     {"CLC", KOC_opcode, 1, 45 },
  1055.     {"CLI", KOC_opcode, 1, 46 },
  1056.     {"CLR", KOC_opcode, 2, 47 },
  1057.     {"CLRA", KOC_opcode, 1, 49 },
  1058.     {"CLRX", KOC_opcode, 1, 50 },
  1059.     {"CMP", KOC_opcode, 3, 51 },
  1060.     {"COM", KOC_opcode, 2, 54 },
  1061.     {"COMA", KOC_opcode, 1, 56 },
  1062.     {"COMX", KOC_opcode, 1, 57 },
  1063.     {"CPU", KOC_CPU, 0, 0 },
  1064.     {"CPX", KOC_opcode, 3, 58 },
  1065.     {"DAA", KOC_opcode, 1, 61 },
  1066.     {"DB", KOC_BDEF, 0, 0 },
  1067.     {"DEC", KOC_opcode, 2, 62 },
  1068.     {"DECA", KOC_opcode, 1, 64 },
  1069.     {"DECX", KOC_opcode, 1, 65 },
  1070.     {"DW", KOC_WDEF, 0, 0 },
  1071.     {"ELSE", KOC_ELSE, 0, 0 },
  1072.     {"END", KOC_END, 0, 0 },
  1073.     {"ENDI", KOC_ENDI, 0, 0 },
  1074.     {"EOR", KOC_opcode, 3, 66 },
  1075.     {"EQU", KOC_EQU, 0, 0 },
  1076.     {"FCB", KOC_BDEF, 0, 0 },
  1077.     {"FCC", KOC_SDEF, 0, 0 },
  1078.     {"FDB", KOC_WDEF, 0, 0 },
  1079.     {"IF", KOC_IF, 0, 0 },
  1080.     {"INC", KOC_opcode, 2, 69 },
  1081.     {"INCA", KOC_opcode, 1, 71 },
  1082.     {"INCL", KOC_INCLUDE, 0, 0 },
  1083.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1084.     {"INCX", KOC_opcode, 1, 72 },
  1085.     {"JMP", KOC_opcode, 2, 73 },
  1086.     {"JSR", KOC_opcode, 2, 75 },
  1087.     {"LDA", KOC_opcode, 3, 77 },
  1088.     {"LDX", KOC_opcode, 3, 80 },
  1089.     {"LSL", KOC_opcode, 2, 83 },
  1090.     {"LSLA", KOC_opcode, 1, 85 },
  1091.     {"LSLX", KOC_opcode, 1, 86 },
  1092.     {"LSR", KOC_opcode, 2, 87 },
  1093.     {"LSRA", KOC_opcode, 1, 89 },
  1094.     {"LSRX", KOC_opcode, 1, 90 },
  1095.     {"MUL", KOC_opcode, 1, 91 },
  1096.     {"NEG", KOC_opcode, 2, 92 },
  1097.     {"NEGA", KOC_opcode, 1, 94 },
  1098.     {"NEGX", KOC_opcode, 1, 95 },
  1099.     {"NOP", KOC_opcode, 1, 96 },
  1100.     {"ORA", KOC_opcode, 3, 97 },
  1101.     {"ORG", KOC_ORG, 0, 0 },
  1102.     {"RESERVE", KOC_RESM, 0, 0 },
  1103.     {"RMB", KOC_RESM, 0, 0 },
  1104.     {"ROL", KOC_opcode, 2, 100 },
  1105.     {"ROLA", KOC_opcode, 1, 102 },
  1106.     {"ROLX", KOC_opcode, 1, 103 },
  1107.     {"ROR", KOC_opcode, 2, 104 },
  1108.     {"RORA", KOC_opcode, 1, 106 },
  1109.     {"RORX", KOC_opcode, 1, 107 },
  1110.     {"RSP", KOC_opcode, 1, 108 },
  1111.     {"RTI", KOC_opcode, 1, 109 },
  1112.     {"RTS", KOC_opcode, 1, 110 },
  1113.     {"SBC", KOC_opcode, 3, 111 },
  1114.     {"SEC", KOC_opcode, 1, 114 },
  1115.     {"SEI", KOC_opcode, 1, 115 },
  1116.     {"SET", KOC_SET, 0, 0 },
  1117.     {"STA", KOC_opcode, 2, 116 },
  1118.     {"STOP", KOC_opcode, 1, 118 },
  1119.     {"STRING", KOC_SDEF, 0, 0 },
  1120.     {"STX", KOC_opcode, 2, 119 },
  1121.     {"SUB", KOC_opcode, 3, 121 },
  1122.     {"SWI", KOC_opcode, 1, 124 },
  1123.     {"TAX", KOC_opcode, 1, 125 },
  1124.     {"TST", KOC_opcode, 2, 126 },
  1125.     {"TSTA", KOC_opcode, 1, 128 },
  1126.     {"TSTX", KOC_opcode, 1, 129 },
  1127.     {"TXA", KOC_opcode, 1, 130 },
  1128.     {"WAIT", KOC_opcode, 1, 131 },
  1129.     {"WORD", KOC_WDEF, 0, 0 },
  1130.     { "", 0, 0, 0 }};
  1131.  
  1132. struct opsynt ostab[NUMSYNBLK+1]
  1133.     = {
  1134. /* invalid 0 */ { 0, 1, 0 },
  1135. /* invalid 1 */ { 0xffff, 1, 1 },
  1136. /* ADC 2 */ { ST_EXP, 2, 2 },
  1137. /* ADC 3 */ { ST_IMM, 1, 4 },
  1138. /* ADC 4 */ { ST_IND, 3, 5 },
  1139. /* ADD 5 */ { ST_EXP, 2, 8 },
  1140. /* ADD 6 */ { ST_IMM, 1, 10 },
  1141. /* ADD 7 */ { ST_IND, 3, 11 },
  1142. /* AND 8 */ { ST_EXP, 2, 14 },
  1143. /* AND 9 */ { ST_IMM, 1, 16 },
  1144. /* AND 10 */ { ST_IND, 3, 17 },
  1145. /* ASL 11 */ { ST_EXP, 1, 20 },
  1146. /* ASL 12 */ { ST_IND, 2, 21 },
  1147. /* ASLA 13 */ { ST_INH, 1, 23 },
  1148. /* ASLX 14 */ { ST_INH, 1, 24 },
  1149. /* ASR 15 */ { ST_EXP, 1, 25 },
  1150. /* ASR 16 */ { ST_IND, 2, 26 },
  1151. /* ASRA 17 */ { ST_INH, 1, 28 },
  1152. /* ASRX 18 */ { ST_INH, 1, 29 },
  1153. /* BCC 19 */ { ST_EXP, 1, 30 },
  1154. /* BCLR 20 */ { ST_BSET, 1, 31 },
  1155. /* BCS 21 */ { ST_EXP, 1, 32 },
  1156. /* BEQ 22 */ { ST_EXP, 1, 33 },
  1157. /* BHCC 23 */ { ST_EXP, 1, 34 },
  1158. /* BHCS 24 */ { ST_EXP, 1, 35 },
  1159. /* BHI 25 */ { ST_EXP, 1, 36 },
  1160. /* BHS 26 */ { ST_EXP, 1, 37 },
  1161. /* BIH 27 */ { ST_EXP, 1, 38 },
  1162. /* BIL 28 */ { ST_EXP, 1, 39 },
  1163. /* BIT 29 */ { ST_EXP, 2, 40 },
  1164. /* BIT 30 */ { ST_IMM, 1, 42 },
  1165. /* BIT 31 */ { ST_IND, 3, 43 },
  1166. /* BLO 32 */ { ST_EXP, 1, 46 },
  1167. /* BLS 33 */ { ST_EXP, 1, 47 },
  1168. /* BMC 34 */ { ST_EXP, 1, 48 },
  1169. /* BMI 35 */ { ST_EXP, 1, 49 },
  1170. /* BMS 36 */ { ST_EXP, 1, 50 },
  1171. /* BNE 37 */ { ST_EXP, 1, 51 },
  1172. /* BPL 38 */ { ST_EXP, 1, 52 },
  1173. /* BRA 39 */ { ST_EXP, 1, 53 },
  1174. /* BRCLR 40 */ { ST_BRSET, 1, 54 },
  1175. /* BRN 41 */ { ST_EXP, 1, 55 },
  1176. /* BRSET 42 */ { ST_BRSET, 1, 56 },
  1177. /* BSET 43 */ { ST_BSET, 1, 57 },
  1178. /* BSR 44 */ { ST_EXP, 1, 58 },
  1179. /* CLC 45 */ { ST_INH, 1, 59 },
  1180. /* CLI 46 */ { ST_INH, 1, 60 },
  1181. /* CLR 47 */ { ST_EXP, 1, 61 },
  1182. /* CLR 48 */ { ST_IND, 2, 62 },
  1183. /* CLRA 49 */ { ST_INH, 1, 64 },
  1184. /* CLRX 50 */ { ST_INH, 1, 65 },
  1185. /* CMP 51 */ { ST_EXP, 2, 66 },
  1186. /* CMP 52 */ { ST_IMM, 1, 68 },
  1187. /* CMP 53 */ { ST_IND, 3, 69 },
  1188. /* COM 54 */ { ST_EXP, 1, 72 },
  1189. /* COM 55 */ { ST_IND, 2, 73 },
  1190. /* COMA 56 */ { ST_INH, 1, 75 },
  1191. /* COMX 57 */ { ST_INH, 1, 76 },
  1192. /* CPX 58 */ { ST_EXP, 2, 77 },
  1193. /* CPX 59 */ { ST_IMM, 1, 79 },
  1194. /* CPX 60 */ { ST_IND, 3, 80 },
  1195. /* DAA 61 */ { ST_INH, 1, 83 },
  1196. /* DEC 62 */ { ST_EXP, 1, 84 },
  1197. /* DEC 63 */ { ST_IND, 2, 85 },
  1198. /* DECA 64 */ { ST_INH, 1, 87 },
  1199. /* DECX 65 */ { ST_INH, 1, 88 },
  1200. /* EOR 66 */ { ST_EXP, 2, 89 },
  1201. /* EOR 67 */ { ST_IMM, 1, 91 },
  1202. /* EOR 68 */ { ST_IND, 3, 92 },
  1203. /* INC 69 */ { ST_EXP, 1, 95 },
  1204. /* INC 70 */ { ST_IND, 2, 96 },
  1205. /* INCA 71 */ { ST_INH, 1, 98 },
  1206. /* INCX 72 */ { ST_INH, 1, 99 },
  1207. /* JMP 73 */ { ST_EXP, 2, 100 },
  1208. /* JMP 74 */ { ST_IND, 3, 102 },
  1209. /* JSR 75 */ { ST_EXP, 2, 105 },
  1210. /* JSR 76 */ { ST_IND, 3, 107 },
  1211. /* LDA 77 */ { ST_EXP, 2, 110 },
  1212. /* LDA 78 */ { ST_IMM, 1, 112 },
  1213. /* LDA 79 */ { ST_IND, 3, 113 },
  1214. /* LDX 80 */ { ST_EXP, 2, 116 },
  1215. /* LDX 81 */ { ST_IMM, 1, 118 },
  1216. /* LDX 82 */ { ST_IND, 3, 119 },
  1217. /* LSL 83 */ { ST_EXP, 1, 122 },
  1218. /* LSL 84 */ { ST_IND, 2, 123 },
  1219. /* LSLA 85 */ { ST_INH, 1, 125 },
  1220. /* LSLX 86 */ { ST_INH, 1, 126 },
  1221. /* LSR 87 */ { ST_EXP, 1, 127 },
  1222. /* LSR 88 */ { ST_IND, 2, 128 },
  1223. /* LSRA 89 */ { ST_INH, 1, 130 },
  1224. /* LSRX 90 */ { ST_INH, 1, 131 },
  1225. /* MUL 91 */ { ST_INH, 1, 132 },
  1226. /* NEG 92 */ { ST_EXP, 1, 133 },
  1227. /* NEG 93 */ { ST_IND, 2, 134 },
  1228. /* NEGA 94 */ { ST_INH, 1, 136 },
  1229. /* NEGX 95 */ { ST_INH, 1, 137 },
  1230. /* NOP 96 */ { ST_INH, 1, 138 },
  1231. /* ORA 97 */ { ST_EXP, 2, 139 },
  1232. /* ORA 98 */ { ST_IMM, 1, 141 },
  1233. /* ORA 99 */ { ST_IND, 3, 142 },
  1234. /* ROL 100 */ { ST_EXP, 1, 145 },
  1235. /* ROL 101 */ { ST_IND, 2, 146 },
  1236. /* ROLA 102 */ { ST_INH, 1, 148 },
  1237. /* ROLX 103 */ { ST_INH, 1, 149 },
  1238. /* ROR 104 */ { ST_EXP, 1, 150 },
  1239. /* ROR 105 */ { ST_IND, 2, 151 },
  1240. /* RORA 106 */ { ST_INH, 1, 153 },
  1241. /* RORX 107 */ { ST_INH, 1, 154 },
  1242. /* RSP 108 */ { ST_INH, 1, 155 },
  1243. /* RTI 109 */ { ST_INH, 1, 156 },
  1244. /* RTS 110 */ { ST_INH, 1, 157 },
  1245. /* SBC 111 */ { ST_EXP, 2, 158 },
  1246. /* SBC 112 */ { ST_IMM, 1, 160 },
  1247. /* SBC 113 */ { ST_IND, 3, 161 },
  1248. /* SEC 114 */ { ST_INH, 1, 164 },
  1249. /* SEI 115 */ { ST_INH, 1, 165 },
  1250. /* STA 116 */ { ST_EXP, 2, 166 },
  1251. /* STA 117 */ { ST_IND, 3, 168 },
  1252. /* STOP 118 */ { ST_INH, 1, 171 },
  1253. /* STX 119 */ { ST_EXP, 2, 172 },
  1254. /* STX 120 */ { ST_IND, 3, 174 },
  1255. /* SUB 121 */ { ST_EXP, 2, 177 },
  1256. /* SUB 122 */ { ST_IMM, 1, 179 },
  1257. /* SUB 123 */ { ST_IND, 3, 180 },
  1258. /* SWI 124 */ { ST_INH, 1, 183 },
  1259. /* TAX 125 */ { ST_INH, 1, 184 },
  1260. /* TST 126 */ { ST_EXP, 1, 185 },
  1261. /* TST 127 */ { ST_IND, 2, 186 },
  1262. /* TSTA 128 */ { ST_INH, 1, 188 },
  1263. /* TSTX 129 */ { ST_INH, 1, 189 },
  1264. /* TXA 130 */ { ST_INH, 1, 190 },
  1265. /* WAIT 131 */ { ST_INH, 1, 191 },
  1266.     { 0, 0, 0 } };
  1267.  
  1268. struct igel igtab[NUMDIFFOP+1]
  1269.     = {
  1270. /* invalid 0 */   { 0 , 0, 
  1271.         "[Xnullentry" },
  1272. /* invalid 1 */   { 0 , 0, 
  1273.         "[Xinvalid opcode" },
  1274. /* ADC 2 */   { ADDR , DIRECT, 
  1275.         "B9;[1=];" },
  1276. /* ADC 3 */   { ADDR , EXTENDED, 
  1277.         "C9;[1=]x" },
  1278. /* ADC 4 */   { 0 , 0, 
  1279.         "A9;[1=];" },
  1280. /* ADC 5 */   { INDEXLEN , INDEX2, 
  1281.         "D9;[1=]x" },
  1282. /* ADC 6 */   { INDEXLEN , INDEX1, 
  1283.         "E9;[1=];" },
  1284. /* ADC 7 */   { INDEXLEN , INDEX0, 
  1285.         "F9;" },
  1286. /* ADD 8 */   { ADDR , DIRECT, 
  1287.         "BB;[1=];" },
  1288. /* ADD 9 */   { ADDR , EXTENDED, 
  1289.         "CB;[1=]x" },
  1290. /* ADD 10 */   { 0 , 0, 
  1291.         "AB;[1=];" },
  1292. /* ADD 11 */   { INDEXLEN , INDEX2, 
  1293.         "DB;[1=]x" },
  1294. /* ADD 12 */   { INDEXLEN , INDEX1, 
  1295.         "EB;[1=];" },
  1296. /* ADD 13 */   { INDEXLEN , INDEX0, 
  1297.         "FB;" },
  1298. /* AND 14 */   { ADDR , DIRECT, 
  1299.         "B4;[1=];" },
  1300. /* AND 15 */   { ADDR , EXTENDED, 
  1301.         "C4;[1=]x" },
  1302. /* AND 16 */   { 0 , 0, 
  1303.         "A4;[1=];" },
  1304. /* AND 17 */   { INDEXLEN , INDEX2, 
  1305.         "D4;[1=]x" },
  1306. /* AND 18 */   { INDEXLEN , INDEX1, 
  1307.         "E4;[1=];" },
  1308. /* AND 19 */   { INDEXLEN , INDEX0, 
  1309.         "F4;" },
  1310. /* ASL 20 */   { ADDR , DIRECT, 
  1311.         "38;[1=];" },
  1312. /* ASL 21 */   { INDEXLEN , INDEX1, 
  1313.         "68;[1=];" },
  1314. /* ASL 22 */   { INDEXLEN , INDEX0, 
  1315.         "78;" },
  1316. /* ASLA 23 */   { 0 , 0, 
  1317.         "48;" },
  1318. /* ASLX 24 */   { 0 , 0, 
  1319.         "58;" },
  1320. /* ASR 25 */   { ADDR , DIRECT, 
  1321.         "37;[1=];" },
  1322. /* ASR 26 */   { INDEXLEN , INDEX1, 
  1323.         "67;[1=];" },
  1324. /* ASR 27 */   { INDEXLEN , INDEX0, 
  1325.         "77;" },
  1326. /* ASRA 28 */   { 0 , 0, 
  1327.         "47;" },
  1328. /* ASRX 29 */   { 0 , 0, 
  1329.         "57;" },
  1330. /* BCC 30 */   { 0 , 0, 
  1331.         "24;[1=].Q.1+-r" },
  1332. /* BCLR 31 */   { 0 , 0, 
  1333.         "11.[1#]|;[2=];" },
  1334. /* BCS 32 */   { 0 , 0, 
  1335.         "25;[1=].Q.1+-r" },
  1336. /* BEQ 33 */   { 0 , 0, 
  1337.         "27;[1=].Q.1+-r" },
  1338. /* BHCC 34 */   { 0 , 0, 
  1339.         "28;[1=].Q.1+-r" },
  1340. /* BHCS 35 */   { 0 , 0, 
  1341.         "29;[1=].Q.1+-r" },
  1342. /* BHI 36 */   { 0 , 0, 
  1343.         "22;[1=].Q.1+-r" },
  1344. /* BHS 37 */   { 0 , 0, 
  1345.         "24;[1=].Q.1+-r" },
  1346. /* BIH 38 */   { 0 , 0, 
  1347.         "2f;[1=].Q.1+-r" },
  1348. /* BIL 39 */   { 0 , 0, 
  1349.         "2e;[1=].Q.1+-r" },
  1350. /* BIT 40 */   { ADDR , DIRECT, 
  1351.         "B5;[1=];" },
  1352. /* BIT 41 */   { ADDR , EXTENDED, 
  1353.         "C5;[1=]x" },
  1354. /* BIT 42 */   { 0 , 0, 
  1355.         "A5;[1=];" },
  1356. /* BIT 43 */   { INDEXLEN , INDEX2, 
  1357.         "D5;[1=]x" },
  1358. /* BIT 44 */   { INDEXLEN , INDEX1, 
  1359.         "E5;[1=];" },
  1360. /* BIT 45 */   { INDEXLEN , INDEX0, 
  1361.         "F5;" },
  1362. /* BLO 46 */   { 0 , 0, 
  1363.         "25;[1=].Q.1+-r" },
  1364. /* BLS 47 */   { 0 , 0, 
  1365.         "23;[1=].Q.1+-r" },
  1366. /* BMC 48 */   { 0 , 0, 
  1367.         "2c;[1=].Q.1+-r" },
  1368. /* BMI 49 */   { 0 , 0, 
  1369.         "2b;[1=].Q.1+-r" },
  1370. /* BMS 50 */   { 0 , 0, 
  1371.         "2d;[1=].Q.1+-r" },
  1372. /* BNE 51 */   { 0 , 0, 
  1373.         "26;[1=].Q.1+-r" },
  1374. /* BPL 52 */   { 0 , 0, 
  1375.         "2a;[1=].Q.1+-r" },
  1376. /* BRA 53 */   { 0 , 0, 
  1377.         "20;[1=].Q.1+-r" },
  1378. /* BRCLR 54 */   { 0 , 0, 
  1379.         "01.[1#]|;[2=];[3=].Q.1+-r" },
  1380. /* BRN 55 */   { 0 , 0, 
  1381.         "21;[1=].Q.1+-r" },
  1382. /* BRSET 56 */   { 0 , 0, 
  1383.         "00.[1#]|;[2=];[3=].Q.1+-r" },
  1384. /* BSET 57 */   { 0 , 0, 
  1385.         "10.[1#]|;[2=];" },
  1386. /* BSR 58 */   { 0 , 0, 
  1387.         "ad;[1=].Q.1+-r" },
  1388. /* CLC 59 */   { 0 , 0, 
  1389.         "98;" },
  1390. /* CLI 60 */   { 0 , 0, 
  1391.         "9a;" },
  1392. /* CLR 61 */   { ADDR , DIRECT, 
  1393.         "3F;[1=];" },
  1394. /* CLR 62 */   { INDEXLEN , INDEX1, 
  1395.         "6F;[1=];" },
  1396. /* CLR 63 */   { INDEXLEN , INDEX0, 
  1397.         "7F;" },
  1398. /* CLRA 64 */   { 0 , 0, 
  1399.         "4F;" },
  1400. /* CLRX 65 */   { 0 , 0, 
  1401.         "5F;" },
  1402. /* CMP 66 */   { ADDR , DIRECT, 
  1403.         "B1;[1=];" },
  1404. /* CMP 67 */   { ADDR , EXTENDED, 
  1405.         "C1;[1=]x" },
  1406. /* CMP 68 */   { 0 , 0, 
  1407.         "A1;[1=];" },
  1408. /* CMP 69 */   { INDEXLEN , INDEX2, 
  1409.         "D1;[1=]x" },
  1410. /* CMP 70 */   { INDEXLEN , INDEX1, 
  1411.         "E1;[1=];" },
  1412. /* CMP 71 */   { INDEXLEN , INDEX0, 
  1413.         "F1;" },
  1414. /* COM 72 */   { ADDR , DIRECT, 
  1415.         "33;[1=];" },
  1416. /* COM 73 */   { INDEXLEN , INDEX1, 
  1417.         "63;[1=];" },
  1418. /* COM 74 */   { INDEXLEN , INDEX0, 
  1419.         "73;" },
  1420. /* COMA 75 */   { 0 , 0, 
  1421.         "43;" },
  1422. /* COMX 76 */   { 0 , 0, 
  1423.         "53;" },
  1424. /* CPX 77 */   { ADDR , DIRECT, 
  1425.         "B3;[1=];" },
  1426. /* CPX 78 */   { ADDR , EXTENDED, 
  1427.         "C3;[1=]x" },
  1428. /* CPX 79 */   { 0 , 0, 
  1429.         "A3;[1=];" },
  1430. /* CPX 80 */   { INDEXLEN , INDEX2, 
  1431.         "D3;[1=]x" },
  1432. /* CPX 81 */   { INDEXLEN , INDEX1, 
  1433.         "E3;[1=];" },
  1434. /* CPX 82 */   { INDEXLEN , INDEX0, 
  1435.         "F3;" },
  1436. /* DAA 83 */   { INSTDAA , INSTDAA, 
  1437.         "8d;" },
  1438. /* DEC 84 */   { ADDR , DIRECT, 
  1439.         "3A;[1=];" },
  1440. /* DEC 85 */   { INDEXLEN , INDEX1, 
  1441.         "6A;[1=];" },
  1442. /* DEC 86 */   { INDEXLEN , INDEX0, 
  1443.         "7A;" },
  1444. /* DECA 87 */   { 0 , 0, 
  1445.         "4A;" },
  1446. /* DECX 88 */   { 0 , 0, 
  1447.         "5A;" },
  1448. /* EOR 89 */   { ADDR , DIRECT, 
  1449.         "B8;[1=];" },
  1450. /* EOR 90 */   { ADDR , EXTENDED, 
  1451.         "C8;[1=]x" },
  1452. /* EOR 91 */   { 0 , 0, 
  1453.         "A8;[1=];" },
  1454. /* EOR 92 */   { INDEXLEN , INDEX2, 
  1455.         "D8;[1=]x" },
  1456. /* EOR 93 */   { INDEXLEN , INDEX1, 
  1457.         "E8;[1=];" },
  1458. /* EOR 94 */   { INDEXLEN , INDEX0, 
  1459.         "F8;" },
  1460. /* INC 95 */   { ADDR , DIRECT, 
  1461.         "3C;[1=];" },
  1462. /* INC 96 */   { INDEXLEN , INDEX1, 
  1463.         "6C;[1=];" },
  1464. /* INC 97 */   { INDEXLEN , INDEX0, 
  1465.         "7C;" },
  1466. /* INCA 98 */   { 0 , 0, 
  1467.         "4C;" },
  1468. /* INCX 99 */   { 0 , 0, 
  1469.         "5C;" },
  1470. /* JMP 100 */   { ADDR , DIRECT, 
  1471.         "BC;[1=];" },
  1472. /* JMP 101 */   { ADDR , EXTENDED, 
  1473.         "CC;[1=]x" },
  1474. /* JMP 102 */   { INDEXLEN , INDEX2, 
  1475.         "DC;[1=]x" },
  1476. /* JMP 103 */   { INDEXLEN , INDEX1, 
  1477.         "EC;[1=];" },
  1478. /* JMP 104 */   { INDEXLEN , INDEX0, 
  1479.         "FC;" },
  1480. /* JSR 105 */   { ADDR , DIRECT, 
  1481.         "BD;[1=];" },
  1482. /* JSR 106 */   { ADDR , EXTENDED, 
  1483.         "CD;[1=]x" },
  1484. /* JSR 107 */   { INDEXLEN , INDEX2, 
  1485.         "DD;[1=]x" },
  1486. /* JSR 108 */   { INDEXLEN , INDEX1, 
  1487.         "ED;[1=];" },
  1488. /* JSR 109 */   { INDEXLEN , INDEX0, 
  1489.         "FD;" },
  1490. /* LDA 110 */   { ADDR , DIRECT, 
  1491.         "B6;[1=];" },
  1492. /* LDA 111 */   { ADDR , EXTENDED, 
  1493.         "C6;[1=]x" },
  1494. /* LDA 112 */   { 0 , 0, 
  1495.         "A6;[1=];" },
  1496. /* LDA 113 */   { INDEXLEN , INDEX2, 
  1497.         "D6;[1=]x" },
  1498. /* LDA 114 */   { INDEXLEN , INDEX1, 
  1499.         "E6;[1=];" },
  1500. /* LDA 115 */   { INDEXLEN , INDEX0, 
  1501.         "F6;" },
  1502. /* LDX 116 */   { ADDR , DIRECT, 
  1503.         "BE;[1=];" },
  1504. /* LDX 117 */   { ADDR , EXTENDED, 
  1505.         "CE;[1=]x" },
  1506. /* LDX 118 */   { 0 , 0, 
  1507.         "AE;[1=];" },
  1508. /* LDX 119 */   { INDEXLEN , INDEX2, 
  1509.         "DE;[1=]x" },
  1510. /* LDX 120 */   { INDEXLEN , INDEX1, 
  1511.         "EE;[1=];" },
  1512. /* LDX 121 */   { INDEXLEN , INDEX0, 
  1513.         "FE;" },
  1514. /* LSL 122 */   { ADDR , DIRECT, 
  1515.         "38;[1=];" },
  1516. /* LSL 123 */   { INDEXLEN , INDEX1, 
  1517.         "68;[1=];" },
  1518. /* LSL 124 */   { INDEXLEN , INDEX0, 
  1519.         "78;" },
  1520. /* LSLA 125 */   { 0 , 0, 
  1521.         "48;" },
  1522. /* LSLX 126 */   { 0 , 0, 
  1523.         "58;" },
  1524. /* LSR 127 */   { ADDR , DIRECT, 
  1525.         "34;[1=];" },
  1526. /* LSR 128 */   { INDEXLEN , INDEX1, 
  1527.         "64;[1=];" },
  1528. /* LSR 129 */   { INDEXLEN , INDEX0, 
  1529.         "74;" },
  1530. /* LSRA 130 */   { 0 , 0, 
  1531.         "44;" },
  1532. /* LSRX 131 */   { 0 , 0, 
  1533.         "54;" },
  1534. /* MUL 132 */   { INSTMUL , INSTMUL, 
  1535.         "42;" },
  1536. /* NEG 133 */   { ADDR , DIRECT, 
  1537.         "30;[1=];" },
  1538. /* NEG 134 */   { INDEXLEN , INDEX1, 
  1539.         "60;[1=];" },
  1540. /* NEG 135 */   { INDEXLEN , INDEX0, 
  1541.         "70;" },
  1542. /* NEGA 136 */   { 0 , 0, 
  1543.         "40;" },
  1544. /* NEGX 137 */   { 0 , 0, 
  1545.         "50;" },
  1546. /* NOP 138 */   { 0 , 0, 
  1547.         "9d;" },
  1548. /* ORA 139 */   { ADDR , DIRECT, 
  1549.         "BA;[1=];" },
  1550. /* ORA 140 */   { ADDR , EXTENDED, 
  1551.         "CA;[1=]x" },
  1552. /* ORA 141 */   { 0 , 0, 
  1553.         "AA;[1=];" },
  1554. /* ORA 142 */   { INDEXLEN , INDEX2, 
  1555.         "DA;[1=]x" },
  1556. /* ORA 143 */   { INDEXLEN , INDEX1, 
  1557.         "EA;[1=];" },
  1558. /* ORA 144 */   { INDEXLEN , INDEX0, 
  1559.         "FA;" },
  1560. /* ROL 145 */   { ADDR , DIRECT, 
  1561.         "39;[1=];" },
  1562. /* ROL 146 */   { INDEXLEN , INDEX1, 
  1563.         "69;[1=];" },
  1564. /* ROL 147 */   { INDEXLEN , INDEX0, 
  1565.         "79;" },
  1566. /* ROLA 148 */   { 0 , 0, 
  1567.         "49;" },
  1568. /* ROLX 149 */   { 0 , 0, 
  1569.         "59;" },
  1570. /* ROR 150 */   { ADDR , DIRECT, 
  1571.         "36;[1=];" },
  1572. /* ROR 151 */   { INDEXLEN , INDEX1, 
  1573.         "66;[1=];" },
  1574. /* ROR 152 */   { INDEXLEN , INDEX0, 
  1575.         "76;" },
  1576. /* RORA 153 */   { 0 , 0, 
  1577.         "46;" },
  1578. /* RORX 154 */   { 0 , 0, 
  1579.         "56;" },
  1580. /* RSP 155 */   { 0 , 0, 
  1581.         "9c;" },
  1582. /* RTI 156 */   { 0 , 0, 
  1583.         "80;" },
  1584. /* RTS 157 */   { 0 , 0, 
  1585.         "81;" },
  1586. /* SBC 158 */   { ADDR , DIRECT, 
  1587.         "B2;[1=];" },
  1588. /* SBC 159 */   { ADDR , EXTENDED, 
  1589.         "C2;[1=]x" },
  1590. /* SBC 160 */   { 0 , 0, 
  1591.         "A2;[1=];" },
  1592. /* SBC 161 */   { INDEXLEN , INDEX2, 
  1593.         "D2;[1=]x" },
  1594. /* SBC 162 */   { INDEXLEN , INDEX1, 
  1595.         "E2;[1=];" },
  1596. /* SBC 163 */   { INDEXLEN , INDEX0, 
  1597.         "F2;" },
  1598. /* SEC 164 */   { 0 , 0, 
  1599.         "99;" },
  1600. /* SEI 165 */   { 0 , 0, 
  1601.         "9b;" },
  1602. /* STA 166 */   { ADDR , DIRECT, 
  1603.         "B7;[1=];" },
  1604. /* STA 167 */   { ADDR , EXTENDED, 
  1605.         "C7;[1=]x" },
  1606. /* STA 168 */   { INDEXLEN , INDEX2, 
  1607.         "D7;[1=]x" },
  1608. /* STA 169 */   { INDEXLEN , INDEX1, 
  1609.         "E7;[1=];" },
  1610. /* STA 170 */   { INDEXLEN , INDEX0, 
  1611.         "F7;" },
  1612. /* STOP 171 */   { INSTSTWA , INSTSTWA, 
  1613.         "8e;" },
  1614. /* STX 172 */   { ADDR , DIRECT, 
  1615.         "BF;[1=];" },
  1616. /* STX 173 */   { ADDR , EXTENDED, 
  1617.         "CF;[1=]x" },
  1618. /* STX 174 */   { INDEXLEN , INDEX2, 
  1619.         "DF;[1=]x" },
  1620. /* STX 175 */   { INDEXLEN , INDEX1, 
  1621.         "EF;[1=];" },
  1622. /* STX 176 */   { INDEXLEN , INDEX0, 
  1623.         "FF;" },
  1624. /* SUB 177 */   { ADDR , DIRECT, 
  1625.         "B0;[1=];" },
  1626. /* SUB 178 */   { ADDR , EXTENDED, 
  1627.         "C0;[1=]x" },
  1628. /* SUB 179 */   { 0 , 0, 
  1629.         "A0;[1=];" },
  1630. /* SUB 180 */   { INDEXLEN , INDEX2, 
  1631.         "D0;[1=]x" },
  1632. /* SUB 181 */   { INDEXLEN , INDEX1, 
  1633.         "E0;[1=];" },
  1634. /* SUB 182 */   { INDEXLEN , INDEX0, 
  1635.         "F0;" },
  1636. /* SWI 183 */   { 0 , 0, 
  1637.         "83;" },
  1638. /* TAX 184 */   { 0 , 0, 
  1639.         "97;" },
  1640. /* TST 185 */   { ADDR , DIRECT, 
  1641.         "3D;[1=];" },
  1642. /* TST 186 */   { INDEXLEN , INDEX1, 
  1643.         "6D;[1=];" },
  1644. /* TST 187 */   { INDEXLEN , INDEX0, 
  1645.         "7D;" },
  1646. /* TSTA 188 */   { 0 , 0, 
  1647.         "4D;" },
  1648. /* TSTX 189 */   { 0 , 0, 
  1649.         "5D;" },
  1650. /* TXA 190 */   { 0 , 0, 
  1651.         "9f;" },
  1652. /* WAIT 191 */   { INSTSTWA , INSTSTWA, 
  1653.         "8f;" },
  1654.     { 0,0,""} };
  1655. /* end fraptabdef.c */
  1656.